home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2010 April / PCWorld0410.iso / pluginy Firefox / 1035 / 1035.xpi / chrome / 1clickweather.jar / content / 1clickweather / js / datadumper.js < prev    next >
Text File  |  2008-10-05  |  7KB  |  240 lines
  1. // ===================================================================
  2. // Author: Matt Kruse <matt@mattkruse.com>
  3. // WWW: http://www.mattkruse.com/
  4. //
  5. // NOTICE: You may use this code for any purpose, commercial or
  6. // private, without any further permission from the author. You may
  7. // remove this notice from your final code if you wish, however it is
  8. // appreciated by the author if at least my web site address is kept.
  9. //
  10. // You may *NOT* re-distribute this code in any way except through its
  11. // use. That means, you can include it in your product, or your web
  12. // site, or any other form where the code is actually being used. You
  13. // may not put the plain javascript up on your site for download or
  14. // include it in your javascript libraries for download. 
  15. // If you wish to share this code with others, please just point them
  16. // to the URL instead.
  17. // Please DO NOT link directly to my .js files from your site. Copy
  18. // the files to your server and use them there. Thank you.
  19. // ===================================================================
  20.  
  21. // HISTORY
  22. // ------------------------------------------------------------------
  23. // March 18, 2004: Updated to include max depth limit, ignoring standard
  24. //    objects, ignoring references to itself, and following only
  25. //    certain object properties.
  26. // March 17, 2004: Created
  27. /* 
  28. DESCRIPTION: These functions let you easily and quickly view the data
  29. structure of javascript objects and variables
  30.  
  31. COMPATABILITY: Will work in any javascript-enabled browser
  32.  
  33. USAGE:
  34.  
  35. // Return the output as a string, and you can do with it whatever you want
  36. var out = Dumper(obj);
  37.  
  38. // When starting to traverse through the object, only follow certain top-
  39. // level properties. Ignore the others
  40. var out = Dumper(obj,'value','text');
  41.  
  42. // Sometimes the object you are dumping has a huge number of properties, like
  43. // form fields. If you are only interested in certain properties of certain 
  44. // types of tags, you can restrict that like Below. Then if DataDumper finds
  45. // an object that is a tag of type "OPTION" it will only examine the properties
  46. // of that object that are specified.
  47. DumperTagProperties["OPTION"] = [ 'text','value','defaultSelected' ]
  48.  
  49. // View the structure of an object in a window alert
  50. DumperAlert(obj);
  51.  
  52. // Popup a new window and write the Dumper output to that window
  53. DumperPopup(obj);
  54.  
  55. // Write the Dumper output to a document using document.write()
  56. DumperWrite(obj);
  57. // Optionall, give it a different document to write to
  58. DumperWrite(obj,documentObject);
  59.  
  60. NOTES: Be Careful! Some objects hold references to their parent nodes, other
  61. objects, etc. Data Dumper will keep traversing these nodes as well, until you
  62. have a really, really huge tree built up. If the object you are passing in has
  63. references to other document objects, you should either:
  64.     1) Set the maximum depth that Data Dumper will search (set DumperMaxDepth)
  65. or
  66.     2) Pass in only certain object properties to traverse
  67. or
  68.     3) Set the object properties to traverse for each type of tag
  69.     
  70. */ 
  71. var DumperIndent = 1;
  72. var DumperIndentText = " ";
  73. var DumperNewline = "\n";
  74. var DumperObject = null; // Keeps track of the root object passed in
  75. var DumperMaxDepth = -1; // Max depth that Dumper will traverse in object
  76. var DumperIgnoreStandardObjects = true; // Ignore top-level objects like window, document
  77. var DumperProperties = null; // Holds properties of top-level object to traverse - others are igonred
  78. var DumperTagProperties = new Object(); // Holds properties to traverse for certain HTML tags
  79. function DumperGetArgs(a,index) {
  80.     var args = new Array();
  81.     // This is kind of ugly, but I don't want to use js1.2 functions, just in case...
  82.     for (var i=index; i<a.length; i++) {
  83.         args[args.length] = a[i];
  84.     }
  85.     return args;
  86. }
  87. function DumperPopup(o) {
  88.     var w = window.open("about:blank");
  89.     w.document.open();
  90.     w.document.writeln("<HTML><BODY><PRE>");
  91.     w.document.writeln(Dumper(o,DumperGetArgs(arguments,1)));
  92.     w.document.writeln("</PRE></BODY></HTML>");
  93.     w.document.close();
  94. }
  95. function DumperAlert(o) {
  96.     alert(Dumper(o,DumperGetArgs(arguments,1)));
  97. }
  98. function DumperWrite(o) {
  99.     var argumentsIndex = 1;
  100.     var d = document;
  101.     if (arguments.length>1 && arguments[1]==window.document) {
  102.         d = arguments[1];
  103.         argumentsIndex = 2;
  104.     }
  105.     var temp = DumperIndentText;
  106.     var args = DumperGetArgs(arguments,argumentsIndex)
  107.     DumperIndentText = " ";
  108.     d.write(Dumper(o,args));
  109.     DumperIndentText = temp;
  110. }
  111. function DumperPad(len) {
  112.     var ret = "";
  113.     for (var i=0; i<len; i++) {
  114.         ret += DumperIndentText;
  115.     }
  116.     return ret;
  117. }
  118. function Dumper(o) {
  119.     var level = 1;
  120.     var indentLevel = DumperIndent;
  121.     var ret = "";
  122.     if (arguments.length>1 && typeof(arguments[1])=="number") {
  123.         level = arguments[1];
  124.         indentLevel = arguments[2];
  125.         if (o == DumperObject) {
  126.             return "[original object]";
  127.         }
  128.     }
  129.     else {
  130.         DumperObject = o;
  131.         // If a list of properties are passed in
  132.         if (arguments.length>1) {
  133.             var list = arguments;
  134.             var listIndex = 1;
  135.             if (typeof(arguments[1])=="object") {
  136.                 list = arguments[1];
  137.                 listIndex = 0;
  138.             }
  139.             for (var i=listIndex; i<list.length; i++) {
  140.                 if (DumperProperties == null) { DumperProperties = new Object(); }
  141.                 DumperProperties[list[i]]=1;
  142.             }
  143.         }
  144.     }
  145.     if (DumperMaxDepth != -1 && level > DumperMaxDepth) {
  146.         return "...";
  147.     }
  148.     if (DumperIgnoreStandardObjects) {
  149.         if (o==window || o==window.document) {
  150.             return "[Ignored Object]";
  151.         }
  152.     }
  153.     // NULL
  154.     if (o==null) {
  155.         ret = "[null]";
  156.         return ret;
  157.     }
  158.     // FUNCTION
  159.     if (typeof(o)=="function") {
  160.         ret = "[function]";
  161.         return ret;
  162.     } 
  163.     // BOOLEAN
  164.     if (typeof(o)=="boolean") {
  165.         ret = (o)?"true":"false";
  166.         return ret;
  167.     } 
  168.     // STRING
  169.     if (typeof(o)=="string") {
  170.         ret = "'" + o + "'";
  171.         return ret;
  172.     } 
  173.     // NUMBER    
  174.     if (typeof(o)=="number") {
  175.         ret = o;
  176.         return ret;
  177.     }
  178.     if (typeof(o)=="object") {
  179.         if (typeof(o.length)=="number" ) {
  180.             // ARRAY
  181.             ret = "[";
  182.             for (var i=0; i<o.length;i++) {
  183.                 if (i>0) {
  184.                     ret += "," + DumperNewline + DumperPad(indentLevel);
  185.                 }
  186.                 else {
  187.                     ret += DumperNewline + DumperPad(indentLevel);
  188.                 }
  189.                 ret += Dumper(o[i],level+1,indentLevel-0+DumperIndent);
  190.             }
  191.             if (i > 0) {
  192.                 ret += DumperNewline + DumperPad(indentLevel-DumperIndent);
  193.             }
  194.             ret += "]";
  195.             return ret;
  196.         }
  197.         else {
  198.             // OBJECT
  199.             ret = "{";
  200.             var count = 0;
  201.             for (i in o) {
  202.                 if (o==DumperObject && DumperProperties!=null && DumperProperties[i]!=1) {
  203.                     // do nothing with this node
  204.                 }
  205.                 else {
  206.                     if (typeof(o[i]) != "unknown") {
  207.                         var processAttribute = true;
  208.                         // Check if this is a tag object, and if so, if we have to limit properties to look at
  209.                         if (typeof(o.tagName)!="undefined") {
  210.                             if (typeof(DumperTagProperties[o.tagName])!="undefined") {
  211.                                 processAttribute = false;
  212.                                 for (var p=0; p<DumperTagProperties[o.tagName].length; p++) {
  213.                                     if (DumperTagProperties[o.tagName][p]==i) {
  214.                                         processAttribute = true;
  215.                                         break;
  216.                                     }
  217.                                 }
  218.                             }
  219.                         }
  220.                         if (processAttribute) {
  221.                             if (count++>0) {
  222.                                 ret += "," + DumperNewline + DumperPad(indentLevel);
  223.                             }
  224.                             else {
  225.                                 ret += DumperNewline + DumperPad(indentLevel);
  226.                             }
  227.                             ret += "'" + i + "' => " + Dumper(o[i],level+1,indentLevel-0+i.length+6+DumperIndent);
  228.                         }
  229.                     }
  230.                 }
  231.             }
  232.             if (count > 0) {
  233.                 ret += DumperNewline + DumperPad(indentLevel-DumperIndent);
  234.             }
  235.             ret += "}";
  236.             return ret;
  237.         }
  238.     }
  239. }
  240.